/**
 * 将行索引和列索引转换为坐标
 * @param {Object} rowIndex - 行索引
 * @param {Object} colIndex - 列索引
 * @returns {Array} 单元格引用如（A1）
 */
export function indexToCoord (rowIndex, colIndex) {
  // 将列索引转换为字母
  let colLetter = '';
  while (colIndex >= 0) {
    colLetter = String.fromCharCode(65 + (colIndex % 26)) + colLetter;
    colIndex = Math.floor(colIndex / 26) - 1;
  }
  // 返回坐标
  return `${colLetter}${rowIndex + 1}`;
}

// 将坐标转换为索引
export function coordToIndex (coord) {
  if (coord === null || coord === undefined) {
    return
  }
  // 提取列字母部分
  const colLetter = coord.match(/[A-Z]+/)[0];
  // 提取行数字部分并转换为数字，行索引从0开始
  const rowIndex = parseInt(coord.match(/[0-9]+/)[0], 10) - 1;

  // 将列字母转换为列索引
  let colIndex = 0;
  for (let i = 0; i < colLetter.length; i++) {
    colIndex = colIndex * 26 + (colLetter.charCodeAt(i) - 65 + 1);
  }
  colIndex -= 1; // 列索引从0开始

  // 返回行索引和列索引
  return { rowIndex, colIndex };
}


/**
 * 获取选区非空单元格（合并单元格视为单个条目）
 * @param {Object} rows - 原始表格数据 {行索引:{cells:{列索引:单元格数据}}}
 * @param {Object} range - 选区范围 {sri:起始行,sci:起始列,eri:结束行,eci:结束列}
 * @returns {Array} 过滤后的扁平化单元格数组
 */
export function getNonEmptyMergedCells (rows, range) {
  const result = [];
  const processed = new Set();

  const isEmpty = (val) => val === null || val === undefined || val === "";

  for (let r = range.sri; r <= range.eri; r++) {
    if (!rows[r]?.cells) continue;

    for (let c = range.sci; c <= range.eci; c++) {
      const cellKey = `${r},${c}`;
      if (processed.has(cellKey)) continue;

      const cell = rows[r].cells[c];
      if (!cell || isEmpty(cell.text)) continue;

      // 处理合并单元格
      if (cell.merge) {
        const [rowSpan, colSpan] = cell.merge;
        for (let i = 0; i <= rowSpan; i++) {
          for (let j = 0; j <= colSpan; j++) {
            processed.add(`${r + i},${c + j}`);
          }
        }
      }
      result.push(Object.assign({
        row: r,
        col: c,
      }, cell));
    }
  }
  return result;
}



/**
 * 根据行号和列号设置单元格的可编辑状态
 * @param {Object} data - 整个数据对象
 * @param {number} rowIndex - 行号
 * @param {number} colIndex - 列号
 * @param {boolean} editable - 是否可编辑
 */
export function setCellEditable (data, rowIndex, colIndex, editable) {
  // 检查行是否存在
  if (data.rows.hasOwnProperty(rowIndex)) {
    const row = data.rows[rowIndex];
    // 检查列是否存在
    if (row.cells.hasOwnProperty(colIndex)) {
      const cell = row.cells[colIndex];
      // 设置单元格的可编辑状态
      cell.editable = editable != null ? editable : true;
    } else {
      console.warn(`列号 ${colIndex} 在行号 ${rowIndex} 中不存在`);
    }
  } else {
    console.warn(`行号 ${rowIndex} 不存在`);
  }
}


export function convertColumnIdentifierToNumber (identifier) {
  // 判断输入是否为数字
  if (!isNaN(identifier)) {
    return parseInt(identifier, 10) - 1; // 列号从0开始
  }

  // 输入为字母，进行字母转数字转换
  let columnNumber = 0;
  const length = identifier.length;
  for (let i = 0; i < length; i++) {
    columnNumber *= 26;
    columnNumber += identifier.charCodeAt(i) - ('A'.charCodeAt(0) - 1);
  }
  return columnNumber - 1; // 列号从0开始
}

//给表头行加入属性
export function updateRowAttributes (tableData, rowIndices, newAttributes) {
  // 判断是否为多行
  const isMultipleRows = rowIndices.includes(',');

  // 获取行索引数组，并调整用户输入的行号
  const rowIndicesArray = isMultipleRows
    ? rowIndices.split(',').map(index => parseInt(index.trim(), 10) - 1)
    : [parseInt(rowIndices, 10) - 1];

  // 遍历每一行并更新属性
  rowIndicesArray.forEach(rowIndex => {
    const row = tableData[0].rows[rowIndex];
    if (!row) {
      console.warn(`行索引 ${rowIndex + 1} 不存在，跳过。`); // 警告信息中显示用户视角的行号
      return;
    }
    // 更新行中所有单元格的属性
    Object.keys(row.cells).forEach(colIndex => {
      Object.assign(row.cells[colIndex], newAttributes);
    });
  });
}
//给表头列加入属性
export function updateColumnAttributes (tableData, colIdentifiers, newAttributes) {
  // 判断是否为多列
  const isMultipleCols = colIdentifiers.includes(',');
  // 获取列索引数组，并将字母或数字转换为数字
  const colIndicesArray = isMultipleCols
    ? colIdentifiers.split(',').map(identifier => convertColumnIdentifierToNumber(identifier))
    : [convertColumnIdentifierToNumber(colIdentifiers)];

  // 获取所有行的数据
  const rows = tableData[0].rows;

  // 遍历每一列并更新属性
  colIndicesArray.forEach(colIndex => {
    // 遍历每一行并更新属性
    Object.keys(rows).forEach(rowIndex => {
      const cell = rows[rowIndex].cells[colIndex];
      if (cell) {
        Object.assign(cell, newAttributes);
      }
    });
  });
}




// 获取指定列中带有isTitle属性的单元格文本值(获取科目列标题)
export function getColumnTitleValues (tableData, colIndex) {
  const rows = Object.values(tableData[0].rows);
  // 获取所在列带有isTitle属性的单元格文本值
  const colTitleValues = rows
    .filter(row => row.cells[colIndex] && row.cells[colIndex].isTitle)
    .map(row => row.cells[colIndex].text)
    .join(',');
  return colTitleValues;
}

// 获取指定行中带有isTitle属性的单元格文本值(获取科目行标题)
export function getRowTitleValues (tableData, rowIndex) {
  const row = tableData[0].rows[rowIndex];
  if (!row) {
    console.warn(`行索引 ${rowIndex} 不存在，跳过。`);
    return '';
  }
  // 获取所在行带有isTitle属性的单元格文本值
  const rowTitleValues = Object.keys(row.cells)
    .filter(cellIndex => row.cells[cellIndex].isTitle)
    .map(cellIndex => row.cells[cellIndex].text)
    .join(',');
  return rowTitleValues;
}

/**
 * 更新JSON数据中指定单元格的属性
 * @param {number} rowIndex - 单元格的行号
 * @param {number} colIndex - 单元格的列号
 * @param {Object} newAttributes - 需要添加或修改的属性
 * @param {Object[]} jsonData - 原始JSON数据
 * @returns {Object[]} - 更新后的JSON数据
 */
// export function updateCellAttributes (rowIndex, colIndex, newAttributes, jsonData) {
//   // 检查行是否存在
//   if (!jsonData[0].rows[rowIndex]) {
//     console.warn(`行索引 ${rowIndex} 不存在，跳过。`);
//     return jsonData;
//   }

//   // 检查列是否存在
//   if (!jsonData[0].rows[rowIndex].cells[colIndex]) {
//     console.warn(`行索引 ${rowIndex}, 列索引 ${colIndex} 的单元格不存在，跳过。`);
//     return jsonData;
//   }

//   // 更新单元格属性
//   Object.assign(jsonData[0].rows[rowIndex].cells[colIndex], newAttributes);

//   return jsonData;
// }
export function updateCellAttributes (rowIndex, colIndex, newAttributes, jsonData) {
  // console.log('更新单元格属性', rowIndex, colIndex, newAttributes, jsonData);

  // 确保rows数组存在
  if (!jsonData[0].rows) {
    jsonData[0].rows = [];
  }

  // 如果行不存在，则新增行
  if (!jsonData[0].rows[rowIndex]) {
    jsonData[0].rows[rowIndex] = { cells: [] };
  }

  // 如果列不存在，则新增列
  if (!jsonData[0].rows[rowIndex].cells[colIndex]) {
    jsonData[0].rows[rowIndex].cells[colIndex] = {};
  }

  // 更新单元格属性
  Object.assign(jsonData[0].rows[rowIndex].cells[colIndex], newAttributes);

  return jsonData;
}


/**
 * 比较两个数组，找出变更的单元格数据
 * @param {Object[]} originalData - 原始数据数组
 * @param {Object[]} updatedData - 变更后的数据数组
 * @returns {Object[]} - 包含变更单元格数据的数组
 */
export function findChangedCells (originalData, updatedData) {
  console.log('比较', originalData, updatedData);

  const changedCells = [];

  // 检查输入参数是否存在
  if (!originalData || !updatedData) {
    console.warn('输入数据不存在，返回空数组');
    return changedCells;
  }

  // 遍历每个工作表
  originalData.forEach((originalSheet, sheetIndex) => {
    // 检查 updatedData 中是否存在对应的工作表
    if (!updatedData[sheetIndex]) {
      console.warn(`工作表索引 ${sheetIndex} 在更新数据中不存在，跳过。`);
      return;
    }

    const updatedSheet = updatedData[sheetIndex];

    // 检查工作表的 rows 是否存在
    if (!originalSheet.rows || !updatedSheet.rows) {
      console.warn(`工作表索引 ${sheetIndex} 的 rows 不存在，跳过。`);
      return;
    }

    // 遍历每个行
    Object.keys(originalSheet.rows).forEach(rowIndex => {
      // 检查更新数据中是否存在对应的行
      if (!updatedSheet.rows[rowIndex]) {
        console.warn(`工作表索引 ${sheetIndex}, 行索引 ${rowIndex} 在更新数据中不存在，跳过。`);
        return;
      }

      const originalRow = originalSheet.rows[rowIndex];
      const updatedRow = updatedSheet.rows[rowIndex];

      // 检查行的 cells 是否存在
      if (!originalRow.cells || !updatedRow.cells) {
        console.warn(`工作表索引 ${sheetIndex}, 行索引 ${rowIndex} 的 cells 不存在，跳过。`);
        return;
      }

      // 遍历每个单元格
      Object.keys(originalRow.cells).forEach(colIndex => {
        // 检查更新数据中是否存在对应的单元格
        if (!updatedRow.cells[colIndex]) {
          console.warn(`工作表索引 ${sheetIndex}, 行索引 ${rowIndex}, 列索引 ${colIndex} 在更新数据中不存在，跳过。`);
          return;
        }

        const originalCell = originalRow.cells[colIndex];
        const updatedCell = updatedRow.cells[colIndex];

        // 比较单元格属性
        if (JSON.stringify(originalCell) !== JSON.stringify(updatedCell)) {
          changedCells.push({
            sheetIndex,
            rowIndex,
            colIndex,
            originalCell,
            updatedCell
          });
        }
      });
    });
  });

  return changedCells;
}



/**
 * 根据条件函数更新表格单元格的属性
 * @param {Object[]} tableData - 表格数据
 * @param {string} attributeName - 要更新的属性名
 * @param {any} attributeValue - 要设置的属性值
 * @param {Function} condition - 条件函数，接收单元格数据作为参数，返回布尔值
 * @returns {Object[]} - 更新后的表格数据
 */
export function updateCellAttributesByCondition (tableData, attributeName, attributeValue, condition) {
  // 遍历每个工作表
  tableData.forEach(sheet => {
    // 遍历每个行
    Object.keys(sheet.rows).forEach(rowIndex => {
      const row = sheet.rows[rowIndex];

      // 检查 row.cells 是否存在
      if (row.cells) {
        // 遍历每个单元格
        Object.keys(row.cells).forEach(colIndex => {
          const cell = row.cells[colIndex];

          // 如果条件函数返回true，则更新属性
          if (condition(cell)) {
            cell[attributeName] = attributeValue;
          }
        });
      }
    });
  });

  return tableData;
}

// const updatedTableData = updateCellAttributesByCondition(
//   tableData,
//   'editable',
//   false,
//   cell => cell.powerType === '1'
// );


//找到powerType为2(可编辑)的单元格
export function findCellsByPowerType (jsonData, powerTypeValue) {
  let foundCells = [];

  // 遍历每个工作表
  jsonData.forEach(sheet => {
    // 遍历每个行
    Object.keys(sheet.rows).forEach(rowIndex => {
      const row = sheet.rows[rowIndex];
      // 检查 row.cells 是否存在
      if (row.cells) {
        // 遍历每个单元格
        Object.keys(row.cells).forEach(colIndex => {
          const cell = row.cells[colIndex];
          // 检查单元格是否存在，并且是否有 powerType 属性，并且属性值等于给定的值
          if (cell && cell.hasOwnProperty('powerType') && cell.powerType == powerTypeValue) {
            foundCells.push(cell);
          }
        });
      } else {
        console.warn(`行索引 ${rowIndex} 的 cells 属性不存在，跳过。`);
      }
    });
  });

  return foundCells;
}


/**
 * 更新样式属性
 * @param {number} styleIndex - 样式索引
 * @param {Object} newAttributes - 要新增或更新的样式属性
 * @param {Array} jsonData - 包含样式的JSON数据
 * @returns {Array} 更新后的JSON数据
 */
export function updateStyleAttributes (styleIndex, newAttributes, jsonData) {
  // 确保styles数组存在
  if (!jsonData[0].styles) {
    jsonData[0].styles = [];
  }

  // 如果样式索引位置不存在，则新增样式对象
  if (!jsonData[0].styles[styleIndex]) {
    jsonData[0].styles[styleIndex] = {};
  }

  // 更新样式属性
  Object.assign(jsonData[0].styles[styleIndex], newAttributes);

  return jsonData;
}
